home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / tex / sspell14.zip / CACHE.C next >
C/C++ Source or Header  |  1992-07-18  |  5KB  |  171 lines
  1. /* **************************************************************** */
  2. /*             sspell - similar to Unix spell                       */
  3. /*                        version 1.4                               */
  4. /*                                                                  */
  5. /* Author: Maurice Castro                                           */
  6. /* Release Date:  4 Jul 1992                                         */
  7. /* Bug Reports: maurice@bruce.cs.monash.edu.au                      */
  8. /*                                                                  */
  9. /* This code has been placed by the Author into the Public Domain.  */
  10. /* The code is NOT covered by any warranty, the user of the code is */
  11. /* solely responsible for determining the fitness of the program    */
  12. /* for their purpose. No liability is accepted by the author for    */
  13. /* the direct or indirect losses incurred through the use of this   */
  14. /* program.                                                         */
  15. /*                                                                  */
  16. /* Segments of this code may be used for any purpose that the user  */
  17. /* deems appropriate. It would be polite to acknowledge the source  */
  18. /* of the code. If you modify the code and redistribute it please   */
  19. /* include a message indicating your changes and how users may      */
  20. /* contact you for support.                                         */
  21. /*                                                                  */
  22. /* The author reserves the right to issue the official version of   */
  23. /* this program. If you have useful suggestions or changes for the  */
  24. /* code, please forward them to the author so that they might be    */
  25. /* incorporated into the official version                           */
  26. /*                                                                  */
  27. /* Please forward bug reports to the author via Internet.           */
  28. /*                                                                  */
  29. /* **************************************************************** */
  30.  
  31. #include "cache.h"
  32. #include <stdio.h>
  33. #if !defined(pyr)
  34. #include <stdlib.h>
  35. #endif
  36. #include "strfn.h"
  37.  
  38. #define NOTINCACHE (0)
  39. #define INCACHE (1)
  40.  
  41. /* this provides a cache of enteries in a list format. The format is a 
  42.    move to front linked list. */
  43.  
  44. /* Author: Maurice Castro */
  45.  
  46. typedef struct liststr
  47. {
  48.    char *name;
  49.    struct liststr *next;
  50.    } LIST;
  51.  
  52. static int maxcachesize;
  53. static int incache;
  54. static LIST *list;
  55.  
  56. void initcache(size)
  57. int size;
  58. {
  59.    list = NULL;
  60.    maxcachesize = size;
  61.    incache = 0;
  62.    }
  63.  
  64. int searchcache(match, actual)
  65. char *match;
  66. char *actual;
  67. { 
  68.    LIST *cur;
  69.    LIST *prev;
  70.    int mtc;
  71.   
  72.    if (list == NULL) return(NOTINCACHE);
  73.  
  74.    cur = list;
  75.    prev = NULL;
  76.    mtc = 0;
  77.  
  78.    while (cur != NULL)
  79.    {
  80.       if (!stricmp(match, cur->name)) 
  81.       {
  82.          mtc = 1;
  83.          break;
  84.          }
  85.       prev = cur;
  86.       cur = cur->next;
  87.       }
  88.    if (!mtc) 
  89.       return(NOTINCACHE);
  90.    if (prev != NULL)
  91.    {
  92.       prev->next = cur->next;
  93.       cur->next = list;
  94.       list = cur;
  95.       }
  96.    strcpy(actual, cur->name);
  97.    return(INCACHE);
  98.    }
  99.  
  100. int addtocache(item)
  101. char *item;
  102. {
  103.     int i;
  104.     LIST *cur;
  105.     LIST *prev;
  106.     LIST *newel;
  107.  
  108.     /* make new element */
  109.     newel = (LIST *) malloc(sizeof(LIST));
  110.     if (newel == NULL)
  111.        return(0);
  112.     newel->name = (char *) malloc(sizeof(char)*(strlen(item)+1));
  113.     strcpy(newel->name, item);
  114.     newel->next = NULL;
  115.  
  116.     /* cache full */
  117.     if (incache >= maxcachesize)   
  118.     {
  119.        /* traverse cache */
  120.        i = 0;
  121.        cur = list;
  122.        while (i < maxcachesize)
  123.        {
  124.           prev = cur;
  125.           cur = cur->next;
  126.           i++;
  127.           }
  128.  
  129.        /* add new element */
  130.        prev->next = NULL;
  131.        newel->next = list;
  132.        list = newel;
  133.        incache = maxcachesize;
  134.  
  135.        /* fix overspill */
  136.        while (cur != NULL)
  137.        {
  138.           prev = cur;
  139.           cur = cur->next; 
  140.           free(prev->name);
  141.           free(prev);
  142.           }
  143.        return(1);
  144.        }
  145.  
  146.     /* cache not full yet */
  147.     incache++;
  148.  
  149.     if (list == NULL)
  150.     {
  151.        list = newel;
  152.        return(1);
  153.        }
  154.     newel->next = list;
  155.     list = newel;
  156.     return(1);
  157.     }
  158.  
  159. /* for debugging use only */
  160.  
  161. void printcache()
  162. {
  163.     LIST *cur;
  164.     cur = list;
  165.     while (cur != NULL)
  166.     {
  167.         printf("%s\n", cur->name);
  168.         cur = cur->next;
  169.         }
  170.     }
  171.